/**
 * 
 */
package com.lucene.demo;

import java.io.File;

import org.apache.commons.io.FileUtils;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.springframework.util.StringUtils;

import com.lucene.parameter.Parameter;

/**
 * @author w.weizhen
 *
 */
public class DemoMain {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        createIndexFile();
        
    }
    
    /**
     * 控制台，实现功能调用的可控性
     *    通过输入信息，调用功能
     */
    private static void console()
    {
        init();//初始化组件
        String command = null;
        while (!"exit".equals(command)) 
        {
            System.out.println("请输入命令:");
            command = Parameter.scanner.nextLine();
            //创建索引文件
            if("createIndex".equals(command))
            {
                createIndexFile();
            }
            //搜索
            else if("search".equals(command))
            {
                String key = null;
                while (key == "Y") 
                {
                    System.out.println("请输入关键字:");
                    key = Parameter.scanner.nextLine();
                    if(key != null && key!= "")
                    {
                        search(key);
                    }
                    System.out.println("是否继续搜索?(Y)");
                    key = Parameter.scanner.nextLine();
                }
            }
            //退出
            else if("exit".equals(command))
            {
                
                
                
            }
            //其他，没有定义，输出说明内容
            else
            {
                
                
                
            }
        }
    }
    
    // 索引写对象
    private static IndexWriter indexWriter;
    // 主目录名称，和其他功能目录相区别
    private static final String package_name = "lucene";
    // 索引文件目录
    private static final String index_dir = Parameter.data_path + package_name + File.separator + "index" + File.separator;
    // 数据文件目录
    private static final String data_dir = Parameter.data_path + package_name + File.separator + "data" + File.separator;
    
    /**
     * 初始化组件
     */
    private static void init()
    {
        try {
            //目录文件目录是否存在，不存在进行创建
            File index_path = new File(index_dir);
            if(!index_path.exists() || !index_path.isDirectory())
            {
                index_path.mkdir();
            }
            
            //指定索引库的存放位置Directory对象
            //Directory directory = FSDirectory.open(Paths.get(index_dir));
            Directory directory = FSDirectory.open(index_path.toPath());
            
            //索引库还可以存放到内存中
            //Directory directory = new RAMDirectory();
            
            //标准分词器，会自动去掉空格，助词等[is/a/the/的等词]
            Analyzer analyzer = new StandardAnalyzer();
            
            //将标准分词器配置到索引的配置中
            IndexWriterConfig config = new IndexWriterConfig(analyzer);
            
            //实例化索引写对象
            indexWriter = new IndexWriter(directory, config);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 创建索引文件
     *   这里使用文本文件进行测试
     */
    private static void createIndexFile()
    {
        try {
            if(indexWriter == null || !indexWriter.isOpen())
            {
                init();
            }
            
            // 数据文件目录
            File data_path = new File(data_dir);
            //目录是否存在，目录中是否有文件
            if(!data_path.exists() || !data_path.isDirectory()) {return;}
            File[] files = data_path.listFiles();
            if(files == null || files.length < 1) {return;}
            
            for (int i = 0; i < files.length; i++) 
            {
                File file = files[i];
                Document doc = new Document();
                //添加字段到文档，一个文档是一个对象、一行数据。类比一个数据对象、数据行
                String contents=FileUtils.readFileToString(file, "UTF-8");
                //创建文件名域
                //第一个参数：域的名称
                //第二个参数：域的内容
                //第三个参数：是否存储
                //是否存储在文档中用Store.YES或Store.NO决定, [Store.YES/Field.Store.YES,两者是同一位置]
                Field contentsField = new TextField("contents", contents, Store.YES);
                doc.add(contentsField);
                
                Field nameField = new TextField("name", file.getName(), Store.YES);
                doc.add(nameField);
                
                Field pathField = new TextField("path", file.getAbsolutePath(), Store.YES);
                doc.add(pathField);
                
                //字符串或流
                //如果是一个Reader, lucene猜测内容比较多,会采用Unstored的策略.
                //TextField(FieldName, FieldValue, Store.NO) 或 TextField(FieldName, reader) 
                
                //字符串
                //这个Field用来构建一个字符串Field，但是不会进行分析，会将整个串存储在索引中，比如(订单号,姓名等)，是否存储在文档中用Store.YES或Store.NO决定
                //StringField(FieldName, FieldValue,Store.YES)) 
                
                //Long型
                //这个Field用来构建一个Long数字型Field，进行分析和索引，比如(价格)，是否存储在文档中用Store.YES或Store.NO决定
                //LongField(FieldName, FieldValue,Store.YES) 
                
                //重载方法，支持多种类型
                //这个Field用来构建不同类型Field, 不分析，不索引，但要Field存储在文档中
                //StoredField(FieldName, FieldValue) 
                
                //使用indexwriter对象将document对象写入索引库，此过程进行索引创建。并将索引和document对象写入索引库。
                indexWriter.addDocument(doc);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            // 关闭写索引
            try {
                indexWriter.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    private static void search(String key)
    {
        try {
            //目录文件目录是否存在，不存在进行创建
            File index_path = new File(index_dir);
            if(!index_path.exists() || !index_path.isDirectory())
            {
                index_path.mkdir();
            }
            
            //指定索引库的存放位置Directory对象
            //Directory directory = FSDirectory.open(Paths.get(index_dir));
            Directory directory = FSDirectory.open(index_path.toPath());
            
            //索引库还可以存放到内存中
            //Directory directory = new RAMDirectory();
            
            
            IndexReader indexReader = DirectoryReader.open(directory);
            
            
            IndexSearcher indexSearcher = new IndexSearcher(indexReader);
            
            //标准分词器，会自动去掉空格，助词等[is/a/the/的等词]
            Analyzer analyzer = new StandardAnalyzer();
            //简体中文分词器
            //SmartChineseAnalyzer analyzer = new SmartChineseAnalyzer();
            
            
            
            QueryParser queryParser = new QueryParser("", analyzer);
            
            
            Query query = queryParser.parse(key);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
}